Methods and systems for implementing redundancy in memory controllers

ABSTRACT

The present disclosure relates to methods and systems for implementing redundancy in memory controllers. The disclosed systems and methods utilize a row of memory blocks, such that each memory block in the row is associated with an independent media unit. Failures of the media units are not correlated, and therefore, a failure in one unit does not affect the data stored in the other units. Parity information associated with the data stored in the memory blocks is stored in a separate memory block. If the data in a single memory block has been corrupted, the data stored in the remaining memory blocks and the parity information is used to retrieve the corrupted data.

CROSS-REFERENCE TO RELATED APPLICATION

The present application claims the benefit of priority under 35 U.S.C. § 120 as a divisional of U.S. patent application Ser. No. 14/564,798 titled “Methods and Systems for Implementing Redundancy in Memory Controllers,” filed on Dec. 9, 2014, the disclosure of which is hereby incorporated by reference in its entirety for all purposes.

FIELD OF THE DISCLOSURE

The present disclosure relates to systems and methods for implementing redundancy in memory controllers.

BACKGROUND

In non-volatile memory based storage devices, such as, NAND flash, phase-change memory (PCM), magnetoresistive RAM (MRAM) or resistive RAM (RRAM or ReRAM) based storage devices, data layout must incorporate redundancy so that failure of a media unit, for example, a flash chip, or failure to reach a media unit, for example, when the connection to the media unit is broken, is tolerated in the system and data remains available.

One approach for implementing redundancy is using exclusive-OR (“XOR”) based parity. According to this approach, data blocks of identical size stored across multiple, independent storage units are XOR'ed to produce a parity block that is stored in a separate media unit. This approach tolerates the failure of one media unit. By XOR'ing the data from the remaining units and the data in the parity block, the data stored in the failed unit can be reconstructed.

Implementing XOR-based redundancy in Non-Volatile Memory (NVM), for example, PCMs. ReRAMs and MRAMs, solid state drives (“SSD”) is especially challenging due to NVM memory characteristics, high performance requirements, requirement to store data consistently in the event of a power loss and space efficiency constraints.

Accordingly, there is a need for an XOR-based parity scheme that meets requirements for high throughput, low latency, flexibility, low space overhead, and robustness against unexpected power loss.

SUMMARY

Methods and systems for implementing redundancy in memory controllers are presented. The disclosed systems and methods utilize a row of memory blocks (storage elements) associated with an independent media unit. Parity information associated with the data stored in the memory blocks is stored in a separate memory block. If the data in a single memory block has been corrupted, the data stored in the remaining memory blocks and the parity information is used to retrieve the corrupted data.

According to aspects of the present disclosure, a method for introducing redundancy in a memory controller is provided. The method can include providing a plurality of data memory elements, each data memory element being associated with a corresponding non-volatile storage element, the plurality of data memory elements including a parity data memory element, and a control memory element comprising a plurality of entries, each entry corresponding to a data memory element from the plurality of data memory elements. The method can also include initializing the plurality of entries of the control memory element to a first value and storing, by the memory controller, a received first data block from a host computer to the first data memory element and, if an entry in the control memory element corresponding to the parity data memory element has the first value, to the parity data memory element. The method can also include changing to a second value an entry in the control memory element corresponding to the first data memory element and the entry in the control memory element corresponding to the parity data memory element, storing a received second data block from the host computer to a second data memory element, and storing to the parity data memory element a result of a logical operation between a value in the second data block and the value in the parity data memory element, if the entry in the control memory element corresponding to the parity data memory element has the second value.

According to aspects of the present disclosure, a method for introducing redundancy in a memory controller is provided. The method can include providing initializing a plurality of data memory elements to a logical zero value, each data memory element being associated with a corresponding non-volatile storage element, the plurality of data memory elements including a parity data memory element. The method can also include receiving, from a host computer, a first data block associated with a first data memory element and storing to the first data memory element a first result of a logical operation between a value in the first data block and a value in the first data memory element. The method can also include storing to the parity data memory element a second result of a logical operation between the value in the first data block and the value in the parity data memory element and receiving, from the host computer, a second data block associated with a second data memory element. The method can also include storing to the second data memory element a third result of a logical operation between a value in the second data block and a value in the second data memory element and storing to the parity data memory element a fourth result of a logical operation between the value in the second data block and the value in the parity data memory element.

According to aspects of the present disclosure, a method for introducing redundancy in a memory controller is provided. The method can include providing a plurality of data memory elements, each data memory element being associated with a corresponding non-volatile storage element, the plurality of data memory elements including a parity data memory element and providing a control memory element comprising a plurality of entries, each entry corresponding to a data memory element from the plurality of data memory elements. The method can also include initializing the plurality of entries of the control memory element to a first value, receiving, from a host computer, a first data block associated with a first data memory element, storing the received first data block to the first data memory element, and storing the received first data block to the parity data memory element, if an entry in the control memory element corresponding to the parity data memory element has the first value. The method can also include changing to a second value an entry in the control memory element corresponding to the first data memory element and changing to the second value the entry in the control memory element corresponding to the parity data memory element. The method can also include receiving, from the host computer, a second data block associated with a second data memory element, storing, by the memory controller, the received second data block to the second data memory element, performing a logical operation between a value in the second data block and the value in the parity data memory element, if the entry in the control memory element corresponding to the parity data memory element has the second value, and storing, by the memory controller, the result of the logical operation to the parity data memory element, if the entry in the control memory element corresponding to the parity data memory element has the second value. The method can also include transferring the stored data from the data memory elements to their corresponding non-volatile storage elements and initializing the data memory elements to a logical zero, after transferring the stored data from the data memory elements to the first non-volatile storage elements.

According to aspects of the present disclosure, a method for introducing redundancy in a memory controller is provided. The method can include providing a plurality of data memory elements, each data memory element being associated with a corresponding non-volatile storage element, the plurality of data memory elements including a parity data memory element and initializing the plurality of data memory elements to a logical zero value. The method can also include receiving, from a host computer, a first data block associated with a first data memory element, performing a logical operation between a value in the first data block and a value in the first data memory element, and storing the result of the logical operation to the first data memory element. The method can also include performing the logical operation between the value in the first data block and the value in the parity data memory element and storing the result of the logical operation to the parity data memory element. The method can also include receiving, from the host computer, a second data block associated with a second data memory element, performing the logical operation between a value in the second data block and a value in the second data memory element, and storing the result of the logical operation to the second data memory element. The method can also include performing the logical operation between the value in the second data block and the value in the parity data memory element and storing the result of the logical operation to the parity data memory element. The method can also include transferring the stored data from the data memory elements to their corresponding non-volatile storage elements and initializing the data memory elements to a logical zero, after transferring the stored data from the data memory elements to the first non-volatile storage elements.

According to aspects of the present disclosure, a memory controller is provided. The memory controller can include a plurality of data memory elements, each data memory element being associated with a corresponding non-volatile storage element, the plurality of data memory elements including a parity data memory element, a control memory element comprising a plurality of entries, each entry corresponding to a data memory element from the plurality of data memory elements, and a controller module. The controller module can be configured to initialize the plurality of entries of the control memory element to a first value, store a received first data block from a host computer to the first data memory element and, if an entry in the control memory element corresponding to the parity data memory element has the first value, to the parity data memory element, and change to a second value an entry in the control memory element corresponding to the first data memory element and the entry in the control memory element corresponding to the parity data memory element. The controller module can be configured to store a received second data block from the host computer to a second data memory element and store to the parity data memory element a result of a logical operation between a value in the second data block and the value in the parity data memory element, if the entry in the control memory element corresponding to the parity data memory element has the second value.

According to aspects of the present disclosure, a memory controller is provided. The memory controller can include a plurality of data memory elements, each data memory element being associated with a corresponding non-volatile storage element, the plurality of data memory elements including a parity data memory element. The memory controller can also include a controller module configured to initialize the plurality of data memory elements to a logical zero value, receive, from a host computer, a first data block associated with a first data memory element, store to the first data memory element a first result of a logical operation between a value in the first data block and a value in the first data memory element, and store to the parity data memory element a second result of a logical operation between the value in the first data block and the value in the parity data memory element. The controller module can be configured to receive, from the host computer, a second data block associated with a second data memory element, store, by the memory controller, to the second data memory element a third result of a logical operation between a value in the second data block and a value in the second data memory element, and store, by the memory controller, to the parity data memory element a fourth result of a logical operation between the value in the second data block and the value in the parity data memory element.

According to aspects of the present disclosure, a memory controller is provided. The memory controller can include a plurality of data memory elements, each data memory element being associated with a corresponding non-volatile storage element, the plurality of data memory elements including a parity data memory element, a control memory element comprising a plurality of entries, each entry corresponding to a data memory element from the plurality of data memory elements, and a controller module. The controller module can be configured to initialize the plurality of entries of the control memory element to a first value, receive, from a host computer, a first data block associated with a first data memory element, store the received first data block to the first data memory element, and store the received first data block to the parity data memory element, if an entry in the control memory element corresponding to the parity data memory element has the first value. The controller module can also be configured to change to a second value an entry in the control memory element corresponding to the first data memory element and change to the second value the entry in the control memory element corresponding to the parity data memory element. The controller module can also be configured to receive a second data block associated with a second data memory element, store the received second data block to the second data memory element, perform a logical operation between a value in the second data block and the value in the parity data memory element, if the entry in the control memory element corresponding to the parity data memory element has the second value, and store the result of the logical operation to the parity data memory element, if the entry in the control memory element corresponding to the parity data memory element has the second value. The controller module can also be configured to transfer the stored data from the data memory elements to their corresponding non-volatile storage elements and initialize the data memory elements to a logical zero, after transferring the stored data from the data memory elements to the first non-volatile storage elements.

According to aspects of the present disclosure, a memory controller is provided. The memory controller can include a plurality of data memory elements, each data memory element being associated with a corresponding non-volatile storage element, the plurality of data memory elements including a parity data memory element. The memory controller can also include a controller module configured to initialize the plurality of data memory elements to a logical zero value, receive, from a host computer, a first data block associated with a first data memory element, perform a logical operation between a value in the first data block and a value in the first data memory element, and store the result of the logical operation to the first data memory element. The controller module can also be configured to perform the logical operation between the value in the first data block and the value in the parity data memory element and store the result of the logical operation to the parity data memory element. The controller module can also be configured to receive a second data block associated with a second data memory element, perform the logical operation between a value in the second data block and a value in the second data memory element, and store the result of the logical operation to the second data memory element. The controller module can also be configured to perform the logical operation between the value in the second data block and the value in the parity data memory element and store the result of the logical operation to the parity data memory element. The controller module can also be configured to transfer the stored data from the data memory elements to their corresponding non-volatile storage elements and initialize the data memory elements to a logical zero, after transferring the stored data from the data memory elements to the first non-volatile storage elements.

BRIEF DESCRIPTION OF THE DRAWINGS

Various objects, features, and advantages of the present disclosure can be more fully appreciated with reference to the following detailed description when considered in connection with the following drawings, in which like reference numerals identify like elements. The following drawings are for the purpose of illustration only and are not intended to be limiting of the invention, the scope of which is set forth in the claims that follow.

FIG. 1 illustrates an exemplary system implementing a communication protocol, in accordance with embodiments of the present disclosure.

FIG. 2 illustrates an exemplary system implementing a redundancy scheme protocol, in accordance with embodiments of the present disclosure.

FIGS. 3A and 3B illustrate exemplary methods for introducing redundancy in a memory controller.

FIGS. 4A and 4B illustrate exemplary methods for introducing redundancy in a memory controller.

DETAILED DESCRIPTION

FIG. 1 shows an illustrative system 100 implementing a communication protocol, in accordance with some embodiments of the present disclosure. System 100 includes host 102 in communication with target device 104 and storage 122. Host 102 includes user applications 106, operating system 108, driver 110, host memory 112, queues 118 a, and communication protocol 114 a. Target device 104 includes interface controller 117, communication protocol 114 b, queues 118 b, and storage controller 120 and storage controller elements 124 in communication with storage 122.

Host 102 can run user-level applications 106 on operating system 108. Operating system 108 can run driver 110 that interfaces with host memory 112. In some embodiments, memory 112 can be dynamic random access memory (DRAM). Host memory 112 can use queues 118 a to store commands from host 102 for target 104 to process. Examples of stored or enqueued commands can include read operations from host 102. Communication protocol 114 a can allow host 102 to communicate with target device 104 using interface controller 117.

Target device 104 can communicate with host 102 using interface controller 117 and communication protocol 114 b. Communication protocol 114 b can provide queues 118 to access storage 122 via storage controller 120. According to aspects of the present disclosure, data flows from the host memory 112, into the storage controller elements 124, and then into storage 122. The disclosed systems and methods implement redundancy when storing and retrieving data via target device 104.

According to aspects of the present disclosure, a number of memory blocks, for example, “n” memory blocks, form a row of memory blocks, such that each memory block in the row is associated with an independent media unit. Accordingly, failures of these media units are not correlated, and therefore, a failure in one unit does not affect the data stored in the other units. This is typically the case in a flash-based SSD where a flash chip can fail, in part or in whole, independently of other flash chips.

FIG. 2 shows an illustration of a system according to aspects of the present disclosure. Specifically, system 200 shows storage controller 120 and storage controller elements 124. Storage controller elements 124 implement memory blocks 210. System 200 also shows storage 122, which includes memory units 220. As discussed above, memory units 220 can be independent media units. The data stored in the various memory blocks in a row, for example, “n” memory blocks, can be named D[0] through D[n−1]. According to aspects of the present disclosure, an XOR-based parity scheme distributes the data across the row of “n” memory blocks 210, such that failure of any one memory unit 220 does not hinder access to the data stored in the corresponding row, e.g., the row formed by memory blocks D[0]-D[n−1]. The parity information can be stored at a parity memory block, D[n], as: D[n]=XOR(D[0], . . . D[n−1]). Specifically, as each D[i] is received (0≤i≤n−1), the parity bits in the parity memory block, D[n], are updated. Therefore, as explained in detail below, elements D[0] . . . D[n−1] are filled spatially, while element D[n] sees repeated data items arriving into it.

An illustrative data recovery in the case of failure of one media unit is as follows: suppose memory M[i] has failed and data D[i] is inaccessible. Data D[i] can be reconstructed by XOR-ing the data from the rest of the memory blocks (including the parity data), as follows: D[i]=XOR(D[0] . . . D[i−1], D[i+1], . . . D[n−1], D[n]).

Efficient implementation of this scheme, however, poses multiple challenges as described below.

Incremental Construction

A first challenge relates to the ability for incremental construction of parity information. Specifically, all data belonging to a row may not be simultaneously presented by the application. The implementation should be capable of storing data of only a subset of the memory blocks in the row, without requiring that the rest of the row's data be also available. Accordingly, the implementation should allow the parity bits to be constructed incrementally, as the data becomes available.

Concurrent Transfers

A second challenge relates to handling concurrent data transfer. Specifically, when there are multiple concurrent data writes to the memory blocks, the parity bits must correctly reflect the XOR operation of all the data that have arrived without forcing a serialization, because serialization will decrease performance.

Buffered Construction

A third challenge relates to concurrent data transfers. In case of block addressable memories, a block of data, e.g., 16 KB, needs to be presented to the memory as a single unit. This is also applicable to the memory hosting the parity data, D[n] which is updated for each D[i] as it arrives. Hence, element D[n] needs to be ready before it can be written to the non-volatile memory. This may require buffered construction, which may result in data corruption, if the write operation is interrupted before all data in the block is written. An example of data corruption because of interruption of the write operation is the “RAID 5 Write Hole” phenomenon. Accordingly, the parity bits cannot be committed to the non-volatile memory, until all the memory blocks in a row are filled. For example, when data arrives one memory block at a time, as a memory block is filled, the parity bits are updated and are expected to be reliably available in the future. However, arrival of data in another memory blocks will cause the parity bits to be updated again. Therefore, the parity bits should be held in an updatable buffer and be committed to the memory only when the entire row has been filled.

Robustness Against Power Loss

A fourth challenge relates to sudden power loss. Specifically, if the device power is suddenly lost during an update of the parity bits, the parity bits in the memory block might not reflect a consistent state. For example, some parity bits might have been updated to incorporate the latest data while other parity bits might only incorporate parity information from earlier writes, and not the latest one. This can compromise the ability to accurately recover data in the event of a future failure.

Incomplete Data Rows

A fifth challenge relates to non-complete data rows. Depending on the data arrival pattern, it is possible that a row may not be entirely filled for relatively long periods of time, or the device may be turned off in a state which contains partially filled rows. When a row is not entirely filled with valid data and a memory block that holds valid data fails, data recovery would still be required even though not all memory blocks of the row are filled. Successful data recovery in this case would require knowing how many and which memory blocks hold valid data. The memory block with the parity information holds the result of the XOR operation of the data of all memory blocks with valid data. Not knowing which memory blocks hold valid data and therefore have contributed to the parity information can lead to data corruption or inability to recover the data, which can results in data loss.

Unbalanced Data Paths

A sixth challenge relates to handling unbalanced data paths. For example, the memory block that holds the parity information receives higher data volume compared to the volume other memory blocks receive. For example, the memory block that holds the parity information can receive up to “n” times the data volume compared to the other memory blocks, because every time data is written to any of the data blocks, the data also “touches” the memory block that holds the parity information. Accordingly, the data distribution pathways should be adequately provisioned to avoid bottlenecks. Efficient implementations can use balancing, such that the volume of data received by each memory unit across the device is not significantly unbalanced.

According to aspects of the present disclosure, the memory blocks, for example, the Controller Storage Elements 124 shown in FIGS. 1 and 2, can be in one of the two states: valid or invalid. For each controller storage element, its corresponding state can be monitored using a control element called a phase bit. For example, when the phase bit of a controller storage element has a value “0” or False, then the corresponding controller memory element is in an invalid state, i.e., it does not hold valid data. When the phase bit of a controller storage element has a value “1” or True, then the corresponding controller memory element is in a valid state, i.e., it holds valid data.

According to aspects of the present disclosure, an illustrative method for transitioning from one state to another is described below. The initial value of the phase bit can be “0.” signifying that the corresponding storage elements are in an invalid state. An incoming data transfer into a first storage element in an invalid state can cause the storage element to store the incoming data into the storage element, and transition the corresponding phase bit to a value of “1.” which would signify that the storage element is in a valid state. i.e., holds valid data. At the same time, if the parity storage element is in an invalid phase, the incoming data is also stored into the parity storage element.

A subsequent incoming data transfer into a second storage element can cause the storage element to store the new data into the second storage element and transition the corresponding bit to a value of “1.” The subsequent data transfer can also cause a “read-modify-write” operation on the data stored in the parity storage element, so that the parity storage element accumulates parity information for the new incoming data. During the “read-modify-write operation,” the data in the parity storage element is retrieved and an XOR operation is performed between the stored data and the new incoming data. Mathematically this can be expressed as Value[i]=Value[i−1]^Data[i], where “i” is the number of times a new data transfer has been received while the parity storage element is in a valid state. The read-modify-operation can be executed for the parity storage element every time there is new incoming data for a particular storage element.

Once the storage controller has moved the data into the non-volatile storage device, for example, storage 122, the storage controller resets the phase bit to “0” again, which signifies an invalid state. Selecting D[n] to serve as the parity storage element is arbitrary. Those skilled in the art would understand that any of the D[0]-D[n−1] can serve as the parity storage element. Different rows of storage elements can have the parity storage element in different positions such that the aggregate traffic seen by a column is balanced.

The method discussed above is illustrated in FIG. 3A. Specifically, a method for introducing redundancy in a storage controller is shown generally in 300. The method provides a plurality of data memory elements (302) and a control memory element to store phase bits (304). Next, the phase bits are initialized to an invalid state (306), for example, a logical zero state. As data is received from the host (308), it is stored into the corresponding data memory element and the corresponding phase bit is changed to hold a valid state (310), for example, a logical one. When new data is received and stored into the corresponding data memory element, the parity phase bit is checked (312). If the parity phase bit is in an invalid state, then the received data is stored into the parity data memory element and the parity phase bit is changed to hold a valid state (314). If the parity bit is in a valid state, then an XOR operation is performed between the received data and the data in the parity data memory element, and the result is stored into the parity data memory element (316). In either case, the method can continue to receive data from host or can transfer the data stored in the data memory elements to the non-volatile memory (318). Once the data is transferred, the phase bits are initialized to an invalid state (306).

The method is also illustrated with a numerical example in FIG. 3B, generally at 350. Specifically, FIG. 3B shows data memory elements, for example, memory blocks 210, and phase bits 352. In the illustrated example, there are “n+1” data memory elements (210), including a parity data memory element, D[n] (353 a), and “n+1” phase bits (352). As explained above, there is a corresponding phase bit for each data memory element. In the illustrated example, the data memory elements are shown as four-bit data blocks, but the present disclosure is not limited to four-bit data blocks and can be applied to any size data block. Initially, the phase bits 352 are all at an invalid state, for example, a logical zero (step 356). As data arrives from the host (354), the data is stored into data memory elements 210 and the corresponding phase bit 352 changes to a valid state. Specifically, in the illustrated example, data block “0101” (354 a) arrives from the host and is stored at D[0] 353 b (step 358). The corresponding phase bit 352 b also changes from a logical zero to a logical one to indicate that D[0] 353 b is in a valid state, i.e., holds valid data. The phase bit 352 a that corresponds to the parity data memory element D[n] 353 a is checked and because, before the new data block arrived phase bit 352 a stored a logical zero value, the received data “0101” 354 a is also stored in the parity data memory element, D[n] 353 a. In addition, the phase bit corresponding to the parity data memory element 352 a is changed to hold a logical one value.

When new data block “1100” 354 b arrives from the host, it can be stored at D[1] 353 c (step 360). The phase bit 352 c that corresponds to D[1] 353 c changes from a logical zero value to a logical one value (step 360) to indicate that D[1] 353 c is in a valid state. The phase bit 352 a of the parity data memory element is checked. Because it holds a logical one value, a read-modify-write is executed to store the new parity information. Specifically, the new parity information is the result of an XOR logical operation between the data stored in the parity data memory element “0101” 353 a and the received data “1100” 354 b. Accordingly, the new parity information “1001” is stored into the parity data memory element D[n] 353 a. If at any point, the data stored in any data memory element is lost or corrupted, it can be retrieved using the parity information. For example, if the data stored in D[0] 353 b was corrupted, it can be restored using the data stored in the remaining data storage elements in a valid state, including the parity data memory element D[n] 353 a. In this case, the information in D[0] 353 b can be restored by XOR-ing the data in D[1] 353 c and the parity information, i.e., value stored in parity data memory element D[n] 353 a. Specifically, the result of an XOR operation between “1100” and “1001” would be “0101,” which corresponds to the correct data in D[0] 353 b.

As new data is received, it is stored in the data memory elements 210 and the parity information is updated for every received data. For example, all data memory elements 210 can hold data received from the host (step 362). FIG. 3B shows that data memory elements D[n−2] 353 d and D[n−1] 353 e store values of “0001” and “0010,” respectively. When the data is transferred to the non-volatile memory, the phase bits 352 are initialized to an invalid state (step 364) and the entire process can start again.

According to alternatives embodiments, the storage elements are always in a valid state and no phase bit is used. The storage elements are initialized to hold a zero value “0.” All incoming data transfers into the storage elements can cause the storage elements to perform a “read-modify-write” operation. The read-modify-write operation is performed for the parity storage element each time there is an incoming data transfer, so that the parity storage element can accumulate parity information for the incoming data. The initial read-modify-operation will perform an XOR operation between “0” and the incoming data. The result of the operation is identical to the incoming data. Accordingly, the incoming data will be stored into the storage element. The read-modify-operation can be executed every time there is new incoming data for the particular storage element. Once the storage controller has moved the data into the non-volatile storage device, for example, storage 122, the storage controller clears the contents of the storage elements, i.e., zeroes their contents, which is equivalent to the phase bit being invalid, as described in the previous embodiment. Zeroing the contents of the storage elements has an associated operation latency and power consumption. However, this implementation does not require storage and maintenance of the phase bits, so the overall memory requirement is less compared to the implementation of the previous embodiment.

The method discussed above is illustrated in FIG. 4A. Specifically, a method for introducing redundancy in a storage controller is shown generally in 400. The method provides a plurality of data memory elements (402) and initializes the data memory elements to a logical zero (404). As data is received from the host (406), an XOR operation is performed between the received data and the data in the corresponding data memory element, and the result is stored into the corresponding data memory element (408). In addition, an XOR operation is performed between the received data and the data in the parity data memory element, and the result is stored into the parity data memory element (410). The method can continue to receive data from host or can transfer the data stored in the data memory elements to the non-volatile memory (412). Once the data is transferred, the data memory elements are initialized to a logical zero (404).

The method is also illustrated with a numerical example in FIG. 4B, generally at 450. Specifically. FIG. 4B shows “n+1” data memory elements, for example, memory blocks 210, including a parity data memory element, D[n] 453 a, however, there are no phase bits. In the illustrated example, the data memory elements 210 are shown as four-bit data blocks, but the present disclosure is not limited to four-bit data blocks and can be applied to any size data block. The data memory elements 210 are all initialized to a logical zero value “0000” (step 456). As data (454) arrives from the host, a first read-modify-write operation is executed to store the new data into a data memory element and a second read-modify-write operation is executed to accumulate the parity information in the parity data memory element. Specifically, the result of a first XOR operation between the stored value “0000” in a data memory element. e.g., D[0] 453 b, and the received data block “0101” 454 a is stored into the data memory element, e.g., D[0] 453 b (step 458). In addition, the result of a second XOR operation between the stored value “0000” in the parity data memory element, D[n] 453 a, and the received data block “0101” 454 a is stored into the parity data memory element, D[n] 453 a (step 458).

When new data block “1100” 454 b arrives from the host, a first read-modify-write operation is executed to store the new data into a data memory element and a second read-modify-write operation is executed to accumulate the parity information in the parity data memory element. Specifically, the result of a first XOR operation between the stored value “0000” in a data memory element, e.g., D[1] 453 c, and the received data block “1100” 454 b is stored into the data memory element, e.g., D[1] 453 c (step 460). The result of a second XOR operation between the stored value “0101” in the parity data memory element, D[n] 453 a, and the received data block “1100” 454 b is stored into the parity data memory element, D[n] 453 a (step 460). If at any point, the data stored in any data memory element is lost or corrupted, it can be retrieved using the parity information. For example, if the data stored in D[0] 453 b was corrupted, it can be restored using the data stored in the remaining data storage elements, including the parity data memory element D[n] 453 a. In this case, the information in D[0] 453 b can be restored by XOR-ing the data in D[1] 453 c and the parity information stored in the parity data memory element, D[n] 453 a. Specifically, the result of an XOR operation between “1100” and “1001” would be “0101.” which corresponds to the correct data in D[0] 453 b. Those of ordinary skill would understand that data memory elements that hold a logical zero value, e.g., “0000” have no effect in the result of the XOR operation.

As new data is received, read-modify-write operations are performed as described above and the parity information is updated for every received data. For example, all data memory elements can hold data received from the host (step 462). FIG. 3B shows that data memory elements D[n−2] 453 d and D[n−1] 453 e store values of “0001” and “0010.” respectively. When the data is transferred to the non-volatile memory, the data memory elements are initialized to a logical zero state (step 464) and the entire process can start again.

In both implementations described above, the storage controller is able to receive multiple interleaved write requests and correctly handle generation of parity bits without requiring ordering among the request or an initialization phase that resets all bits to zero. This solves the problems of (a) Incremental Construction (b) Concurrent Transfers and (c) Buffered Construction, described above, before the eventual write to the non-volatile memory. For example, the disclosed systems can use multi-ported SRAM blocks in an FPGA that perform either copying of the incoming data into the memory (invalid state) or performing a read-modify-write XOR operation of incoming data with the present data (valid state).

According to aspects of the present disclosure, the disclosed systems and methods provide robustness against sudden power loss by guaranteeing that data transfer among controller storage elements are atomic against power loss. For example, the storage controller can guarantee that once a transfer between controller storage elements has initiated, it is always completed, for example, by using a backup power circuitry present in the target device in case of a power failure. Accordingly, the power-safe data transfers can also ensure that there is no partial update or corruption of the parity bits.

As discussed above, it is desirable to know which data transfers have contributed to the accumulated parity, i.e., which storage elements hold valid data. According to aspects of the present disclosure, a parity bit vector, for example, an XOR bit vector, is defined and each contributing data transfer is assigned a bit position in a bit vector. When a particular data transfer completes, the corresponding bit is set in the parity bit vector. The parity bit vector is stored along with the data as well as the parity blocks in NVM. On recovery from a power loss event, the parity bit vector is available to reconstruct the data from the valid parity and data bits. If under alternative implementations, the memory elements are zeroed, then there is no requirement to know which storage elements hold valid data. Accordingly, there is no requirement for a parity bit vector. If however, under a particular implementation, only the memory elements holding valid data are zeroed, then it is desirable to know which memory elements hold valid data, because only those elements contribute to the parity information.

As further discussed above, the parity storage element receives more data traffic compared to the data storage elements. According to aspects of the present disclosure, to prevent the skew in data bandwidth distribution, the location of the parity bits for each subsequent data row is rotated. This ensures that in aggregate each controller storage element receives uniform traffic.

Those of skill in the art would appreciate that the various illustrations in the specification and drawings described herein can be implemented as electronic hardware, computer software, or combinations of both. To illustrate this interchangeability of hardware and software, various illustrative blocks, modules, elements, components, methods, and algorithms have been described above generally in terms of their functionality. Whether such functionality is implemented as hardware, software, or a combination depends upon the particular application and design constraints imposed on the overall system. Skilled artisans can implement the described functionality in varying ways for each particular application. Various components and blocks can be arranged differently (for example, arranged in a different order, or partitioned in a different way) all without departing from the scope of the subject technology.

Furthermore, an implementation of the communication protocol can be realized in a centralized fashion in one computer system, or in a distributed fashion where different elements are spread across several interconnected computer systems. Any kind of computer system, or other apparatus adapted for carrying out the methods described herein, is suited to perform the functions described herein.

A typical combination of hardware and software could be a general purpose computer system with a computer program that, when being loaded and executed, controls the computer system such that it carries out the methods described herein. The methods for the communications protocol can also be embedded in a computer program product, which comprises all the features enabling the implementation of the methods described herein, and which, when loaded in a computer system is able to carry out these methods.

Computer program or application in the present context means any expression, in any language, code or notation, of a set of instructions intended to cause a system having an information processing capability to perform a particular function either directly or after either or both of the following a) conversion to another language, code or notation; b) reproduction in a different material form. Significantly, this communications protocol can be embodied in other specific forms without departing from the spirit or essential attributes thereof, and accordingly, reference should be had to the following claims, rather than to the foregoing specification, as indicating the scope of the invention.

The communications protocol has been described in detail with specific reference to these illustrated embodiments. It will be apparent, however, that various modifications and changes can be made within the spirit and scope of the disclosure as described in the foregoing specification, and such modifications and changes are to be considered equivalents and part of this disclosure. 

What is claimed is:
 1. A method for introducing redundancy in a memory controller, the method comprising: initializing, by the memory controller, a plurality of data memory elements to a logical zero value, each data memory element being associated with a corresponding non-volatile storage element, the plurality of data memory elements including a parity data memory element; receiving, from a host computer, a first data block associated with a first data memory element; storing, by the memory controller, to the first data memory element a first result of a logical operation between a value in the first data block and a value in the first data memory element; storing, by the memory controller, to the parity data memory element a second result of a logical operation between the value in the first data block and the value in the parity data memory element; receiving, from the host computer, a second data block associated with a second data memory element; storing, by the memory controller, to the second data memory element a third result of a logical operation between a value in the second data block and a value in the second data memory element; storing, by the memory controller, to the parity data memory element a fourth result of a logical operation between the value in the second data block and the value in the parity data memory element.
 2. The method of claim 1, further comprising: transferring, by the memory controller, the stored data from the data memory elements to their corresponding non-volatile storage elements; and initializing, by the memory controller, the data memory elements to a logical zero, after transferring the stored data from the data memory elements to the first non-volatile storage elements.
 3. The method of claim 1, wherein the logical operations are exclusive OR logical operations.
 4. The method of claim 3, wherein a value in the parity data memory element is stored incrementally.
 5. The method of claim 3, wherein a value stored in a first data memory element can be restored from the values of the data memory elements in a valid state and a value of the parity data memory element.
 6. The method of claim 1, wherein each corresponding non-volatile storage element is located in an independent media unit.
 7. A memory controller comprising: a plurality of data memory elements, each data memory element being associated with a corresponding non-volatile storage element, the plurality of data memory elements including a parity data memory element; and a controller module configured to: initialize the plurality of data memory elements to a logical zero value; receive, from a host computer, a first data block associated with a first data memory element; store to the first data memory element a first result of a logical operation between a value in the first data block and a value in the first data memory element; store to the parity data memory element a second result of a logical operation between the value in the first data block and the value in the parity data memory element; receive, from the host computer, a second data block associated with a second data memory element; store, by the memory controller, to the second data memory element a third result of a logical operation between a value in the second data block and a value in the second data memory element; store, by the memory controller, to the parity data memory element a fourth result of a logical operation between the value in the second data block and the value in the parity data memory element.
 8. The memory controller of claim 7, wherein the controller module is further configured to: transfer the stored data from the data memory elements to their corresponding non-volatile storage elements; and initialize the data memory elements to a logical zero, after transferring the stored data from the data memory elements to the first non-volatile storage elements.
 9. The memory controller of claim 7, wherein the logical operations are exclusive OR logical operations.
 10. The memory controller of claim 9, wherein a value in the parity data memory element is stored incrementally.
 11. The memory controller of claim 9, wherein a value stored in a first data memory element can be restored from the values of the data memory elements in a valid state and a value of the parity data memory element.
 12. The memory controller of claim 7, wherein each corresponding non-volatile storage element is located in an independent media unit. 